<?php

class myLib
{


 //metodo para leer el array list
 function xml2array($contents, $get_attributes=1, $priority = 'tag') {
    if(!$contents) return array();

    if(!function_exists('xml_parser_create')) {
        //print "'xml_parser_create()' function not found!";
        return array();
    }

    //Get the XML parser of PHP - PHP must have this module for the parser to work
    $parser = xml_parser_create('');
    xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, "UTF-8"); # http://minutillo.com/steve/weblog/2004/6/17/php-xml-and-character-encodings-a-tale-of-sadness-rage-and-data-loss
    xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
    xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
    xml_parse_into_struct($parser, trim($contents), $xml_values);
    xml_parser_free($parser);

    if(!$xml_values) return;//Hmm...

    //Initializations
    $xml_array = array();
    $parents = array();
    $opened_tags = array();
    $arr = array();

    $current = &$xml_array; //Refference

    //Go through the tags.
    $repeated_tag_index = array();//Multiple tags with same name will be turned into an array
    foreach($xml_values as $data) {
        unset($attributes,$value);//Remove existing values, or there will be trouble

        //This command will extract these variables into the foreach scope
        // tag(string), type(string), level(int), attributes(array).
        extract($data);//We could use the array by itself, but this cooler.

        $result = array();
        $attributes_data = array();

        if(isset($value)) {
            if($priority == 'tag') $result = $value;
            else $result['value'] = $value; //Put the value in a assoc array if we are in the 'Attribute' mode
        }

        //Set the attributes too.
        if(isset($attributes) and $get_attributes) {
            foreach($attributes as $attr => $val) {
                if($priority == 'tag') $attributes_data[$attr] = $val;
                else $result['attr'][$attr] = $val; //Set all the attributes in a array called 'attr'
            }
        }

        //See tag status and do the needed.
        if($type == "open") {//The starting of the tag '<tag>'
            $parent[$level-1] = &$current;
            if(!is_array($current) or (!in_array($tag, array_keys($current)))) { //Insert New tag
                $current[$tag] = $result;
                if($attributes_data) $current[$tag. '_attr'] = $attributes_data;
                $repeated_tag_index[$tag.'_'.$level] = 1;

                $current = &$current[$tag];

            } else { //There was another element with the same tag name

                if(isset($current[$tag][0])) {//If there is a 0th element it is already an array
                    $current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;
                    $repeated_tag_index[$tag.'_'.$level]++;
                } else {//This section will make the value an array if multiple tags with the same name appear together
                    $current[$tag] = array($current[$tag],$result);//This will combine the existing item and the new item together to make an array
                    $repeated_tag_index[$tag.'_'.$level] = 2;

                    if(isset($current[$tag.'_attr'])) { //The attribute of the last(0th) tag must be moved as well
                        $current[$tag]['0_attr'] = $current[$tag.'_attr'];
                        unset($current[$tag.'_attr']);
                    }

                }
                $last_item_index = $repeated_tag_index[$tag.'_'.$level]-1;
                $current = &$current[$tag][$last_item_index];
            }

        } elseif($type == "complete") { //Tags that ends in 1 line '<tag />'
            //See if the key is already taken.
            if(!isset($current[$tag])) { //New Key
                $current[$tag] = $result;
                $repeated_tag_index[$tag.'_'.$level] = 1;
                if($priority == 'tag' and $attributes_data) $current[$tag. '_attr'] = $attributes_data;

            } else { //If taken, put all things inside a list(array)
                if(isset($current[$tag][0]) and is_array($current[$tag])) {//If it is already an array...

                    // ...push the new element into that array.
                    $current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;

                    if($priority == 'tag' and $get_attributes and $attributes_data) {
                        $current[$tag][$repeated_tag_index[$tag.'_'.$level] . '_attr'] = $attributes_data;
                    }
                    $repeated_tag_index[$tag.'_'.$level]++;

                } else { //If it is not an array...
                    $current[$tag] = array($current[$tag],$result); //...Make it an array using using the existing value and the new value
                    $repeated_tag_index[$tag.'_'.$level] = 1;
                    if($priority == 'tag' and $get_attributes) {
                        if(isset($current[$tag.'_attr'])) { //The attribute of the last(0th) tag must be moved as well

                            $current[$tag]['0_attr'] = $current[$tag.'_attr'];
                            unset($current[$tag.'_attr']);
                        }

                        if($attributes_data) {
                            $current[$tag][$repeated_tag_index[$tag.'_'.$level] . '_attr'] = $attributes_data;
                        }
                    }
                    $repeated_tag_index[$tag.'_'.$level]++; //0 and 1 index is already taken
                }
            }

        } elseif($type == 'close') { //End of tag '</tag>'
            $current = &$parent[$level-1];
        }
    }

    return($xml_array);
}

/*
 * Servicio se encarga de obtener los programas vistos y almacenarlos por id
 */
public function executeObtener_lista_programas($array_ids){

  //arreglos
  $id = "";
  $contador = 0;
for($i=0; $i<strlen($array_ids); $i++){
    if($array_ids[$i]==","){
      $criteria_bus = new Criteria();
      $criteria_bus->add(ListaProgramasMonitoreoPeer::ID,$id);
      $objeto= ListaProgramasMonitoreoPeer::doSelectOne($criteria_bus);
      $programas[$contador] = $objeto->getNombrePrograma();
      $contador++;
      $id = "";
    }else{
        $id =  $id.$array_ids[$i];
    }
}
if($contador>0){
    $criteria_bus3 = new Criteria();
      $criteria_bus3->add(ListaProgramasMonitoreoPeer::ID,$id);
      $objeto= ListaProgramasMonitoreoPeer::doSelectOne($criteria_bus3);
      $programas[$contador] = $objeto->getNombrePrograma();
}


return $programas;

}
public function executeObtener_consumo($tabla){
  // lo recibo como json
  //arreglos
  $id = "";
  $contador = 0;

for($i=0; $i<strlen($tabla); $i++){
    if($tabla[$i]==";"){

        $consumo[$contador] = $id;
        $contador++;
        $id = "";

    }else{
        $id =  $id.$tabla[$i];
    }
}
if($contador>0){
   $consumo[$contador] = $id;
}
return $consumo;

}
public function executeObtener_programa_id($id){
  // lo recibo como json
  //arreglos
$criteria = new Criteria();
$criteria ->add(ListaProgramasMonitoreoPeer::ID,$id);
$cant = ListaProgramasMonitoreoPeer::doCount($criteria);
if($cant>0){

    $obj = ListaProgramasMonitoreoPeer::doSelectOne($criteria);
    $nombre = $obj->getNombrePrograma();
    return $nombre;

}else{

    return null;

}


}
public function executeV($ob){

}

public function executeRetornar_valores_torta($array){
$cont_nombre_programa = 0;
$array_list = array();
$arreglo_aux = array();
$cont=0; $aux=0;
for($i=0; $i<count($array); $i++){
$aux++;
  if($cont == 1){

   $nombre_programa = $this->executeObtener_programa_id($array[$i]);
       $cont++;
            }
         else{
  if($cont > 1){
      $tiempo = $array[$i];
      $arreglo =  array('nombre'  =>  $nombre_programa, 'tiempo'  =>  $tiempo );
      array_push($array_list,$arreglo);
      $cont=0;

  }else{
      $cont++;
  }
}

           }
 $array_editado = $this->executeExaminar_arreglo($array_list);
   return $array_editado  /*$array_list*/;
}

/*
 * Metodo que devuelve datos para el grafico general
 * 1) obtengo los nombres de los programas usados
 * 2)
 */
public function executeRetorna_arreglo_nombres($array){

             $obj = json_decode($rows->getArrayConsumo());
                $array_fechas_consumo[] = $rows->getFecha();
                for($i=0; $i<24; $i++){
                        if(isset ($obj->{$i}))
                                    foreach ($obj->{$i} as $row){
                                             foreach( $row as $file){
                                                  $array_lista_programas_aux[] =  $file;
                                             }
                                        }

                }
             $array_editado = $this->executeExaminar_arreglo($array_lista_programas_aux);
                return $array_editado;


}

public function executeRetorna_programas_hora_inicio($array){
$cont_nombre_programa = 0;
$array_list = array();
$arreglo_aux = array();
$cont=0; $aux=0;

for($i=0; $i<count($array); $i++){
$aux++;
if($cont == 0)
$hora_inicio = $array[$i];
  if($cont == 1){

   $nombre_programa = $this->executeObtener_programa_id($array[$i]);
       $cont++;
            }
         else{
  if($cont > 1){
      $tiempo = $array[$i];
      $arreglo =  array( 'hora_inicio' => $hora_inicio, 'nombre' =>  $nombre_programa, 'tiempo' =>  $tiempo );
      array_push($array_list,$arreglo);
      $cont=0;

  }else{
      $cont++;
  }
}

           }
/* $array_editado = $this->executeExaminar_arreglo($array_list);*/
   return   $array_list;
}


public function executeRetorna_cantidad_programas($array){
     $cont=0; $aux=0;
     $nombres_programas = array();
  
     for($i=0; $i<count($array); $i++){

        if($cont == 0){
   
    $cont++;

    }else{
            if($cont == 1){


       // echo $recurso->executeObtener_programa_id($lista_consumo[$i]);
        $cont ++;
        $nombre = $this->executeObtener_programa_id($array[$i]);
        $nombres_programas[]=$nombre;
            }
         else{

            // echo $lista_consumo[$i]. ' Min';
            $cont=0;

            }
           }
           }
         
        
         return $nombres_programas;

}
public function executeRetorna_programas($array){
     $cont=0; $aux=0;
     $nombres_programas = array();
     $horas_programas = array();
     $hora = 0;
     for($i=0; $i<count($array); $i++){

        if($cont == 0){
    //"08:20","1","10"
    $horas_programas[] = substr($array[$i], 0, 2);
    $cont++;

    }else{
            if($cont == 1){


       // echo $recurso->executeObtener_programa_id($lista_consumo[$i]);
        $cont ++;
        $nombre = $this->executeObtener_programa_id($array[$i]);
        $nombres_programas[]=$nombre;
            }
         else{

            // echo $lista_consumo[$i]. ' Min';
            $cont=0;

            }
           }
           }
         // return $nombres_programas;
         $arreglobidemensional[][] = array();
         $arreglobidemensional = $this->executeExaminar_arreglo_nombres($nombres_programas, $horas_programas);
         return $arreglobidemensional;
        //return $nombres_programas;
}
public function executeExaminar_arreglo_nombres($programas,$horas_programas){

//limpio los nombres de las aplicaciones.


$arreglo1[][] = "NADA";
//leno la primera columna con los datos de los programas
    for($i=1;$i<=count($programas); $i++ )
        $arreglo1[$i][0] = $programas[$i-1];
 // lleno las horas en la parte superior
    for($x=1;$x<=25;$x++){
     $arreglo1[0][$x] = $x-1;
    }
 //formo los datos para el grafico
    $cont=0;

    for($j=1;$j<=count($horas_programas);$j++){
        for($h=1;$h<=24;$h++){
           if($h-1 == $horas_programas[$j-1]){
                 $arreglo1[$j][$h] = $horas_programas[$j-1];
        }
        }

    }



return $arreglo1;


}


public function executePintar_grafico_general($datos,$fechas_busquedas){
//Arreglo bidimensional



     $html = '<table  id="estadistica_tabla" style="display:none;"><caption>2009 Individual Sales by Category</caption><thead>  <tr><td></td>';
     for($i=0; $i<count($fechas_busquedas); $i++){

                       $html .= '<th scope="col">'.$fechas_busquedas[$i].'</th>';

                         }
    $html .= '</tr></thead><tbody>';
             foreach($datos as $ob){


           $jsondv =  $ob->getArrayConsumo();

           // decodifico json
           $obj = json_decode($jsondv);

           $array_lista_consumo_aux = array();

                        for($id = 0 ; $id < 24; $id++){
                            if( isset($obj->{$id}) ){
                                   foreach ($obj->{$id} as $row){
                                         foreach( $row as $file){
                                                   $array_lista_consumo_aux[] = $file;
                                                 }
                                     }
                            }
                        }
              $array_editado = $this->executeRetornar_valores_torta($array_lista_consumo_aux);
            $cont=0; for($j=0;$j<count($array_lista_consumo_aux); $j++){

            if($cont > 0){
     $html .= '<tr>';
                        if ($cont == 1) {
      $html .='<th scope="row">'.$this->executeObtener_programa_id($array_lista_consumo_aux[$j]).'</th>';
                        $cont++; } else {
       $html .= '<td>'.$array_lista_consumo_aux[$j].'</td>';
                         $cont = 0;

                         }

    $html .= '</tr>';
                 }else $cont++;

                 } }
                 $html .= '</tbody></table>';
return $html;
}
/*
 *
 *
 *
 */
public function executePintar_grafico_bidimensional($datos){
//Arreglo bidimensional

$cabecera  = array();

             foreach($datos as $ob){

           $jsondv =  $ob->getArrayConsumo();

           // decodifico json
           $obj = json_decode($jsondv);

           $array_lista_consumo_aux = array();

                        for($id = 0 ; $id < 24; $id++){
                            if( isset($obj->{$id}) ){
                                   foreach ($obj->{$id} as $row){
                                         foreach( $row as $file){
                                                   $array_lista_consumo_aux[] = $file;
                                                 }
                                     }
                            }
                        }
              $array_editado = $this->executeRetornar_valores_torta($array_lista_consumo_aux);


               foreach($array_editado as $key => $value){


                            $cabecera[] = $value{'nombre'};


              }
              //limpio el arreglo (Verifico que no se repita los nombres)
              $arreglo = $this->executeVerifica_arreglo($cabecera);

              }




  // $file = 1;
    //ARMO LA CABECERA
          for($j=0; $j<count($arreglo); $j++){
                $arreglo_cuerpo_grafico[0][$j] = $arreglo[$j];
            }
     /*FIN*/

     //ARMO EL CUERPO
$fila = 1;
       foreach($datos as $ob2){

           $jsondv2 =  $ob2->getArrayConsumo();

           // decodifico json
           $obj2 = json_decode($jsondv2);

           $array_lista_consumo_aux2 = array();

                        for($id = 0 ; $id < 24; $id++){
                            if( isset($obj2->{$id}) ){
                                   foreach ($obj2->{$id} as $row2){
                                         foreach( $row2 as $file2){
                                                   $array_lista_consumo_aux2[] = $file2;
                                                 }
                                     }
                            }
                        }
              $array_editado = $this->executeRetornar_valores_torta($array_lista_consumo_aux2);


               foreach($array_editado as $key => $value){

                  //recorro la cabecera
                   for($g=0; $g<count($arreglo); $g++){
                           if( $arreglo_cuerpo_grafico[0][$g] == $value{'nombre'}){
                               $arreglo_cuerpo_grafico[$fila][$g] = $value{'tiempo'};
                           }
                   }

              }

$fila++;
              }

return $arreglo_cuerpo_grafico;
}
/*
 *
 */
public function executeExaminar_arreglo($array){

    $arreglo_aux = array();
      $arreglo_aux = $array;
      $cont = 0;

    $arreglo_aux2 = array();
    $arreglo_nombres = array();
    $arreglo_bbb = array();
    foreach ($array as $key => $value1){
       $cont=0;
       $cont2 = 0;
         foreach($arreglo_bbb as $key4 => $value4){
                if($value4{'nombre_t'} == $value1{'nombre'}){
                     $cont2++;
                     break;
                }
            }
            if($cont2==0){
        foreach ($arreglo_aux as $key2 => $value2){
            if($value1{'nombre'} == $value2{'nombre'}){
                $cont++;
               if($cont>1){
                    $temporal_nombre =  $value2{'nombre'};
                    $temporal_tiempo = $value2{'tiempo'}+$temporal_tiempo;
                    $arreglo_nombres = array('nombre_t' =>  $temporal_nombre );
                    array_push($arreglo_bbb, $arreglo_nombres);
                }else{
                $temporal_nombre =  $value2{'nombre'};
                $temporal_tiempo = $value2{'tiempo'};
                }
            }
        }



            $arreglo_xxx =  array('nombre' =>  $temporal_nombre, 'tiempo' =>  $temporal_tiempo );

            array_push($arreglo_aux2,$arreglo_xxx);



}
    }
return $arreglo_aux2;
}
/*
 *
 */
public function executeVerifica_arreglo($array){

    $arreglo_aux = array();
      $arreglo_aux = $array;
      $cont = 0;
      $arreglo_aux2 = array();
    $arreglo_nombres = array();
    $arreglo_bbb = array();

    //Recorro el Arreglo enviado como parametro
    for($i=0;$i<count($array); $i++){
       $cont=0;
       $cont2 = 0;
        //recorro bbb
       for($j=0; $j<count($arreglo_bbb); $j++){
           if($arreglo_bbb[$j] == $array[$i]){
                 $cont2++;
                     break;
           }
       }
         if($cont2==0){
             for($z=0; $z<count($arreglo_aux); $z++){
                 if($array[$i] == $arreglo_aux[$z]){
                      $cont++;
               if($cont>1){
                     $temporal_nombre =  $arreglo_aux[$z];
                    // $arreglo_nombres[] = ;
                     $arreglo_bbb[] =  $arreglo_aux[$z];
                     }else{
                     $temporal_nombre =  $arreglo_aux[$z];
                     }
                 }
             }
            $arreglo_aux2[] = $temporal_nombre;



         }
    }
return $arreglo_aux2;
}
public function  executeCantidad_cabecera($datos){
 $cabecera  = array();

             foreach($datos as $ob){

           $jsondv =  $ob->getArrayConsumo();

           // decodifico json
           $obj = json_decode($jsondv);

           $array_lista_consumo_aux = array();

                        for($id = 0 ; $id < 24; $id++){
                            if( isset($obj->{$id}) ){
                                   foreach ($obj->{$id} as $row){
                                         foreach( $row as $file){
                                                   $array_lista_consumo_aux[] = $file;
                                                 }
                                     }
                            }
                        }
              $array_editado = $this->executeRetornar_valores_torta($array_lista_consumo_aux);


               foreach($array_editado as $key => $value){


                            $cabecera[] = $value{'nombre'};


              }
              //limpio el arreglo (Verifico que no se repita los nombres)
              $arreglo = $this->executeVerifica_arreglo($cabecera);

              }
             return count($arreglo);

}
public function executeCantidad_rows($datos){
$rows = 0;
    foreach($datos as $ob){
        $rows++;
    }
return $rows+1;

}
//metodo que recibe como parametro un email de un usuario y retorna si
//existe en la BD
public function executeValida_usuario_monitoreado($email_monitoreado){

    $new_criteria = new Criteria();
    $new_criteria ->add(UsuarioPeer::EMAIL,$email_monitoreado, Criteria::LIKE);
    $new_criteria ->add(UsuarioPeer::ESTADO,"1", Criteria::LIKE);
    $obj_cant_usuario = UsuarioPeer::doCount($new_criteria);

    if($obj_cant_usuario>0){
        $obj_user = UsuarioPeer::doSelectOne($new_criteria);
        return $obj_user;
    }else{
        return null;
    }

}

public function executeRetornaCodigoProceso($nombre_proceso){
   //$nombre_proceso = "netbeans.exe";

    $new_criteria_bus = new Criteria();
    $new_criteria_bus->add(ListaProgramasMonitoreoPeer::NOMBRE_SISTEMA,$nombre_proceso);
    $obj_cant_usuario = ListaProgramasMonitoreoPeer::doCount($new_criteria_bus);
    if($obj_cant_usuario>0){
         $obj_registro = ListaProgramasMonitoreoPeer::doSelectOne($new_criteria_bus);
         return $obj_registro->getId();
    }else{
        return "0";
    }
}
// en el primer envio de datos si hay procesos repetidos este metodo calcula el tiempo de uso mayor de ese
// proceso
public function executeCalcularTiempoUsoReal($arreglo){

$array_aux = $arreglo;
$array_limpia_programas = array();
$array_real_return = array(); 
$array_historial = array();

foreach ($arreglo as $key => $value){
  $contador = 0;
  $contador_historial = 0;
  foreach($array_aux as $key2 => $value2){

    
      // verificamos si existe en el historial
      if($this->executeValidarArreglo_noreply($array_historial, $value{'codigo'}) == null){

            if($value{'codigo'} == $value2{'codigo'} && $contador == 0){
            $temp_codigo = $value{'codigo'};
            $temp_tiempo =  $value{'tiempo'};
            $contador++;
            }else{
              if($value{'codigo'} == $value2{'codigo'}  && $contador > 0 ){

                  if($value2{'tiempo'} > $temp_tiempo){
                      $temp_tiempo = $value2{'tiempo'};
                  }

              }

          }
      }else{
              
             
                $result = $this->executeValidarArreglo_noreply($array_historial, $value{'codigo'});

                $lista2 = explode('-', $array_historial[$result]);
               if($value{'tiempo'} > $lista2[1]){
                     $array_historial[$result] = $lista2[0]."-".$value{'tiempo'};
                  }

              
               
               


      }

     }
        if($contador > 0 ){
          $array_historial[] = $temp_codigo."-".$temp_tiempo;
          $contador=0;
        }
             

        /*if($contador_historial == 0){

            $array_limpia_programas =  array('codigo' =>  $temp_codigo, 'tiempo' =>  $temp_tiempo );
              array_push($array_real_return,$array_limpia_programas);
        }*/

    }

for($i=0; $i<count($array_historial); $i++){
  
 $lista = explode('-', $array_historial[$i]);
 $array_limpia_programas =  array('codigo' =>  $lista[0], 'tiempo' =>  $lista[1] );
 array_push($array_real_return,$array_limpia_programas);
}

return $array_real_return;

}


//verificar 

function executeValidarArreglo_noreply($array_historial, $codigo){
   // verificamos en el historial
  // verificamos en el historial
      for($i=0; $i<count($array_historial); $i++){
          

          $lista2 = explode('-', $array_historial[$i]);

          if( $lista2[0]  == $codigo){
            
              return $i;
          }

      }
      return null;
}
// autogenerar token

function executeAutogenerarCadena(){
  $length = 8;
  $string = "";
  $possible = "0123456789bcdfghjkmnpqrstvwxyz";
  $i = 0;
  while ($i < $length) {
    $char = substr($possible, mt_rand(0, strlen($possible)-1), 1);
    $string .= $char;
    $i++;
  }
  return $string;
}

// calcular las horas conectadas.
// formato de fechas : 2012-02-01 09:10:50
function executeCalcularTiempoSesion($fecha_inicio, $array_hora_inicio, $fecha_fin, $array_hora_fin){

if(count($array_hora_inicio)>0)
$hora_inicio = $array_hora_inicio[0];
else
$hora_inicio = "00:00:00";
if(count($array_hora_fin)>0){
    $i = count($array_hora_fin)-1;
    $hora_fin = $array_hora_fin[$i];
}else{
    $hora_fin = date("H:i:s");
}

$inicio = $fecha_inicio." ".$hora_inicio;
$fin = $fecha_fin." ".$hora_fin;
list($fechaAct, $horaAct) = explode(" ", $fin);
list($yearAct, $mesAct, $dayAct) = explode("-", $fechaAct);
list($horaAct, $minAct, $secAct) = explode(":", $horaAct);
list($fechaAnt, $horaAnt) = explode(" ", $inicio);
list($yearAnt, $mesAnt, $dayAnt) = explode("-", $fechaAnt);
list($horaAnt, $minAnt, $secAnt) = explode(":", $horaAnt);
$sAct = mktime($horaAct, $minAct, $secAct, $mesAct, $dayAct, $yearAct);
$sAnt = mktime($horaAnt, $minAnt, $secAnt, $mesAnt, $dayAnt, $yearAnt);
$diffSeg = $sAct - $sAnt;
$diffMin = $diffSeg / 60;
$diffHoras = $diffMin / 60;

$resultado =" En Horas: ". floor($diffHoras)."| En Minutos: ".floor($diffMin). "| En Segundos: ".floor($diffSeg);
return $resultado;

}

public function executeVerificarRegistroProcesos($nombre_proceso, $titulo_programa){

  if($nombre_proceso != null)
  {

      $new = new Criteria();
      $new->add(ListaProgramasMonitoreoPeer::NOMBRE_SISTEMA, $nombre_proceso);

      $obj_registro = ListaProgramasMonitoreoPeer::doSelectOne($new);

      //verifico si existe

       if(!(is_object($obj_registro)))
       {

            if($titulo_programa !=null)
            {

               //logica para registrar nuevo registro en la lista de programas
              $var_programa_titulo  = $titulo_programa;
              $arreglo = explode("-", $var_programa_titulo);
              $nombre_programa = $arreglo[count($arreglo)-1];
            }
            else
            {
              $nombre_programa = "unknown";
            }

               //inserto nuevo registro
               $new_registro = new ListaProgramasMonitoreo();
               $new_registro->setNombrePrograma($nombre_programa);
               $new_registro->setNombreSistema($nombre_proceso);
               $new_registro->setEstado("H");
               $new_registro->save();

                return "ok";


        }

  }

}
public function executeInsertarHistorial($array, $codigo_cliente, $hora_envio_server){


$cadena="";
  $fecha = date("Y-m-d H:i");
$utc_date = DateTime::createFromFormat(
                'Y-m-d G:i',
                $fecha,
                new DateTimeZone('UTC')
);

$nyc_date = $utc_date;
$nyc_date->setTimeZone(new DateTimeZone('America/Lima'));

  //realiza consulta en la base de datos del detalle
  $fecha_envio_server = $nyc_date->format('Y-m-d');


  $new_criteria = new criteria();
  $new_criteria->add(DetalleConsumoUsuarioPeer::FECHA, "%".$fecha_envio_server."%",Criteria::LIKE );
  $new_criteria->add(DetalleConsumoUsuarioPeer::USUARIO_ID,$codigo_cliente,Criteria::LIKE);
  $obj_historial = DetalleConsumoUsuarioPeer::doSelectOne($new_criteria);
  if(is_object($obj_historial)){
      if($obj_historial->getArrayHistorialAplicaciones() != null){ //--> si existen registros en la BD

    $historial = $obj_historial->getArrayHistorialAplicaciones();

    for($i = 0; $i< count($array) ; $i++){
         $historial .= $array[$i]."+";
      }
      $historial = $historial.$hora_envio_server."*";

      $obj_historial->setArrayHistorialAplicaciones($historial);
      $obj_historial->save();

  }else{

       for($i = 0; $i< count($array) ; $i++){
         $cadena .= $array[$i]."+";
      }
       $cadena = $cadena.$hora_envio_server."*";

       $obj_historial->setArrayHistorialAplicaciones($cadena);
       $obj_historial->save();

  }
  }


}

public function executeLimpiarArregloAplicativosHistorial($arreglo_aplicativos){

    $array_aux = $arreglo_aplicativos;
    $new_arreglo = array();
    for($i=0; $i < count($arreglo_aplicativos); $i++){
        $cont=0;
        for($j=0; $j<count($array_aux) ; $j++){
            
            if(trim($array_aux[$j])==$arreglo_aplicativos[$i] && $cont==0 ){
                  
                if($this->validar_arreglo_no_duplicado($new_arreglo,trim($array_aux[$j]))){
 
                    $new_arreglo[] = trim($array_aux[$j]);
                    $cont++;
                }else{
                  
                  $cont++;

                }



            }

        }

    }

    return $new_arreglo;

}

function validar_arreglo_no_duplicado($arreglo_aplicativos, $variable){

    for($i=0; $i<count($arreglo_aplicativos); $i++){
        
        if( $arreglo_aplicativos [$i]== $variable ){
             return false;
        }

    }
    return true;

}

public function executeRetornarDataHistorial($aplicacion, $datageneral){
  
    $lista = explode('*', $datageneral);
    for($i=0; $i<count($lista); $i++){
       $lista2 = $lista[$i];
       $lista2 = explode('+', $lista2);
    
      for($j=0; $j<count($lista2); $j++){
          
        $new_arreglo = explode('-', $lista2[$j]);

        if(trim($new_arreglo[count($new_arreglo)-1]) == $aplicacion){
          
           $array_general[] = $lista2[$j];

        }
           
       }
     }

       return $array_general;

}

public function executeRetornaFechaLocal(){
  
        $fecha = date("Y-m-d H:i");
        $utc_date = DateTime::createFromFormat(
                        'Y-m-d G:i',
                        $fecha,
                        new DateTimeZone('UTC')
        );

        $nyc_date = $utc_date;
        $nyc_date->setTimeZone(new DateTimeZone('America/Lima'));
        //$nyc_date->setTimeZone(new DateTimeZone('Africa/Johannesburg'));

        $fecha_local = $nyc_date->format('Y-m-d');

        return $fecha_local;

}


}